using BingAuto;
using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;

namespace Tools
{
    public enum LogLevel
    {
        Info,
        Warning,
        Error
    }

    public static class Logger
    {
        // 日志文件存储路径
        private static readonly string logFolderPath;
        
        // 上次执行日志清理的日期
        private static DateTime lastCleanupDate = DateTime.MinValue;
        
        // 静态构造函数，初始化日志文件夹路径
        static Logger()
        {
            // 获取应用程序缓存路径
            logFolderPath = Path.Combine(BingServer.appCachePath, "Logs");
            
            // 确保日志文件夹存在
            if (!Directory.Exists(logFolderPath))
            {
                Directory.CreateDirectory(logFolderPath);
            }
        }
        
        /// <summary>
        /// 检查是否需要执行日志清理（每天第一次记录日志时执行）
        /// </summary>
        private static void CheckAndCleanupLogs()
        {
            try
            {
                // 获取当前日期（只比较年月日）
                DateTime currentDate = DateTime.Today;
                
                // 如果上次清理日期不是今天，则执行清理
                if (lastCleanupDate.Date != currentDate.Date)
                {
                    CleanupOldLogs();
                    lastCleanupDate = currentDate;
                }
            }
            catch { /* 忽略检查过程中的异常 */ }
        }
        
        /// <summary>
        /// 清理过期的日志文件，只保留最近7天的日志
        /// </summary>
        private static void CleanupOldLogs()
        {
            try
            {
                // 获取7天前的日期
                DateTime cutoffDate = DateTime.Now.AddDays(-7);
                
                // 获取日志文件夹中的所有日志文件
                string[] logFiles = Directory.GetFiles(logFolderPath, "log_*.txt");
                
                foreach (string logFile in logFiles)
                {
                    try
                    {
                        // 尝试从文件名提取日期
                        string fileName = Path.GetFileNameWithoutExtension(logFile);
                        if (fileName.StartsWith("log_"))
                        {
                            string datePart = fileName.Substring(4); // 去掉"log_"
                            
                            // 解析日期
                            if (DateTime.TryParseExact(datePart, "yyyyMMdd", null, 
                                                     System.Globalization.DateTimeStyles.None, out DateTime fileDate))
                            {
                                // 如果文件日期早于截止日期，则删除该文件
                                if (fileDate < cutoffDate)
                                {
                                    File.Delete(logFile);
                                }
                            }
                        }
                    }
                    catch { /* 忽略单个文件处理失败的异常，继续处理其他文件 */ }
                }
            }
            catch { /* 忽略日志清理过程中的异常 */ }
        }
        
        // 获取当前日期的日志文件路径
        private static string GetLogFilePath()
        {
            string dateString = DateTime.Now.ToString("yyyyMMdd");
            return Path.Combine(logFolderPath, $"log_{dateString}.txt");
        }
        
        // 异步写入日志
        public static async Task LogAsync(LogLevel level, string operation, string message)
        {
            try
            {
                // 检查是否需要执行日志清理
                CheckAndCleanupLogs();
                
                string logEntry = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] [{level}] [{operation}] {message}\r\n";
                string filePath = GetLogFilePath();
                
                // 异步写入日志文件 (使用.NET Framework兼容的方式)
                using (StreamWriter writer = File.AppendText(filePath))
                {
                    await writer.WriteAsync(logEntry);
                    await writer.FlushAsync();
                }
            }
            catch { /* 忽略日志写入失败的异常 */ }
        }
        
        // 同步写入日志（用于无法使用异步的场景）
        public static void Log(LogLevel level, string operation, string message)
        {
            try
            {
                // 检查是否需要执行日志清理
                CheckAndCleanupLogs();
                
                string logEntry = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] [{level}] [{operation}] {message}\r\n";
                string filePath = GetLogFilePath();
                
                // 同步写入日志文件
                File.AppendAllText(filePath, logEntry, Encoding.UTF8);
            }
            catch { /* 忽略日志写入失败的异常 */ }
        }
        
        // 便捷方法：记录信息日志
        public static async Task InfoAsync(string operation, string message)
        {
            await LogAsync(LogLevel.Info, operation, message);
        }
        
        // 便捷方法：记录警告日志
        public static async Task WarningAsync(string operation, string message)
        {
            await LogAsync(LogLevel.Warning, operation, message);
        }
        
        // 便捷方法：记录错误日志
        public static async Task ErrorAsync(string operation, string message)
        {
            await LogAsync(LogLevel.Error, operation, message);
        }
        
        // 便捷方法：记录信息日志（同步）
        public static void Info(string operation, string message)
        {
            Log(LogLevel.Info, operation, message);
        }
        
        // 便捷方法：记录警告日志（同步）
        public static void Warning(string operation, string message)
        {
            Log(LogLevel.Warning, operation, message);
        }
        
        // 便捷方法：记录错误日志（同步）
        public static void Error(string operation, string message)
        {
            Log(LogLevel.Error, operation, message);
        }
        
        // 记录异常信息
        public static async Task LogExceptionAsync(string operation, Exception ex)
        {
            string message = $"异常: {ex.Message}\r\n堆栈跟踪: {ex.StackTrace}";
            await ErrorAsync(operation, message);
        }
        
        // 记录异常信息（同步）
        public static void LogException(string operation, Exception ex)
        {
            string message = $"异常: {ex.Message}\r\n堆栈跟踪: {ex.StackTrace}";
            Error(operation, message);
        }
    }
}